GridPACK: export_xform33.hpp Source File

00001 /*
00002  *     Copyright (c) 2013 Battelle Memorial Institute
00003  *     Licensed under modified BSD License. A copy of this license can be found
00004  *     in the LICENSE file in the top level directory of this distribution.
00005  */
00006 /*
00007  * export_xform33.hpp
00008  *
00009  * This class exports transformer data in PSS/E v33 format
00010  *
00011  *  Created on: April 17, 2019
00012  *      Author: Bruce Palmer
00013  */
00014 
00015 #ifndef EXPORTXFORM33_HPP_
00016 #define EXPORTXFORM33_HPP_
00017 
00018 #include <iostream>
00019 #include <string>
00020 #include <vector>
00021 #include <map>
00022 
00023 #include "gridpack/parallel/communicator.hpp"
00024 #include "gridpack/component/data_collection.hpp"
00025 #include "gridpack/parser/dictionary.hpp"
00026 #include "gridpack/network/base_network.hpp"
00027 #include "gridpack/export/base_export.hpp"
00028 
00029 namespace gridpack {
00030 namespace expnet {
00031 
00032 template <class _network>
00033 class ExportXform33
00034 {
00035   public:
00036 
00037     /**
00038      * Constructor
00039      */
00040     explicit ExportXform33(boost::shared_ptr<_network> network) :
00041       p_network(network), p_comm(network->communicator())
00042     {
00043     }
00044 
00045     /**
00046      * Destructor
00047      */
00048     virtual ~ExportXform33(){}
00049 
00050     /**
00051      * export text to fstream
00052      * @param fout stream object to export data
00053      * @param text_data vector of text strings that should be written out
00054      *                  consecutively, based on values in text_line data
00055      *                  data structures.
00056      */
00057     void writeXformBlock(std::ofstream &fout)
00058     {
00059       BaseExport<_network> exprt(p_comm);
00060       int me = p_comm.rank();
00061       // Form vector of text strings based from data collection objects
00062       int nbranch = p_network->numBranches();
00063       gridpack::component::DataCollection *data;
00064       int i, j;
00065       char buf[MAX_STRING_SIZE];
00066       std::vector<text_line> text_data;
00067       for (i=0; i<nbranch; i++) {
00068         if (p_network->getActiveBranch(i)) {
00069           data = p_network->getBranchData(i).get();
00070           double rval;
00071           int ival;
00072           int idx1, idx2;
00073           std::string sval;
00074           DoubleComplex zval;
00075           char *ptr;
00076           int nline = 0;
00077           double tap_ratio;
00078           data->getValue(BRANCH_NUM_ELEMENTS,&nline);
00079           for (j=0; j<nline; j++) {
00080             ptr = buf;
00081             data->getValue(BRANCH_TAP,&tap_ratio,j);
00082             bool is_xform = data->getValue(TRANSFORMER_WINDV1,&rval,j);
00083             is_xform = is_xform && data->getValue(TRANSFORMER_WINDV2,&rval,j);
00084             if (is_xform || (tap_ratio != 0.0 && tap_ratio != 1.0)) {
00085               // Note that three winding buses have already been converted to
00086               // regular lines and buses. May want to revisit this issue in
00087               // the future
00088               data->getValue(BRANCH_FROMBUS,&idx1);
00089               data->getValue(BRANCH_TOBUS,&idx2);
00090               ival = 1;
00091               data->getValue(BRANCH_SWITCHED,&ival,j);
00092               // First line
00093               if (ival == 1) {
00094                 sprintf(ptr,"%d, %d, 0,",idx1,idx2);
00095               } else {
00096                 sprintf(ptr,"%d, %d, 0,",idx2,idx1);
00097               }
00098               ptr += strlen(ptr);
00099               sval = " 1";
00100               data->getValue(BRANCH_CKT,&sval,j);
00101               sprintf(ptr," \'%s\',",sval.c_str());
00102               ptr += strlen(ptr);
00103               // Assume default value for CW
00104               sprintf(ptr," 1,");
00105               ptr += strlen(ptr);
00106               // Assume default value for CZ
00107               sprintf(ptr," 1,");
00108               ptr += strlen(ptr);
00109               // Assume default value for CM
00110               sprintf(ptr," 1,");
00111               ptr += strlen(ptr);
00112               rval = 0.0;
00113               data->getValue(TRANSFORMER_MAG1,&rval,j);
00114               sprintf(ptr," %f,",rval);
00115               ptr += strlen(ptr);
00116               rval = 0.0;
00117               data->getValue(TRANSFORMER_MAG2,&rval,j);
00118               sprintf(ptr," %f,",rval);
00119               ptr += strlen(ptr);
00120               ival = 2;
00121               data->getValue(TRANSFORMER_NMETR,&ival,j);
00122               sprintf(ptr," %d,",ival);
00123               ptr += strlen(ptr);
00124               ival = 1;
00125               sprintf(ptr," \'            \',");
00126               ptr += strlen(ptr);
00127               data->getValue(BRANCH_STATUS,&ival,j);
00128               sprintf(ptr," %d,",ival);
00129               ptr += strlen(ptr);
00130               ival = 1;
00131               data->getValue(BRANCH_O1,&ival,j);
00132               rval = 0.0;
00133               data->getValue(BRANCH_F1,&rval,j);
00134               sprintf(ptr," %d, %f,",ival,rval);
00135               ptr += strlen(ptr);
00136               ival = 0;
00137               data->getValue(BRANCH_O2,&ival,j);
00138               rval = 0.0;
00139               data->getValue(BRANCH_F2,&rval,j);
00140               sprintf(ptr," %d, %f,",ival,rval);
00141               ptr += strlen(ptr);
00142               ival = 0;
00143               data->getValue(BRANCH_O3,&ival,j);
00144               rval = 0.0;
00145               data->getValue(BRANCH_F3,&rval,j);
00146               sprintf(ptr," %d, %f,",ival,rval);
00147               ptr += strlen(ptr);
00148               ival = 0;
00149               data->getValue(BRANCH_O4,&ival,j);
00150               rval = 0.0;
00151               data->getValue(BRANCH_F4,&rval,j);
00152               sprintf(ptr," %d, %f,",ival,rval);
00153               ptr += strlen(ptr);
00154               // VECGRP just defaults to 12 blanks
00155               sprintf(ptr,"\'            \'\n");
00156               ptr += strlen(ptr);
00157 
00158               // Second line
00159               rval = 0.0;
00160               if (!data->getValue(TRANSFORMER_R1_2,&rval,j)) {
00161                 data->getValue(BRANCH_R,&rval,j);
00162               }
00163               sprintf(ptr,"%f,",rval);
00164               ptr += strlen(ptr);
00165               if (!data->getValue(TRANSFORMER_X1_2,&rval,j)) {
00166                 data->getValue(BRANCH_X,&rval,j);
00167               }
00168               sprintf(ptr," %f,",rval);
00169               ptr += strlen(ptr);
00170               if (!data->getValue(TRANSFORMER_SBASE1_2,&rval,j)) {
00171                 data->getValue(CASE_SBASE,&rval);
00172               }
00173               sprintf(ptr," %f,\n",rval);
00174               ptr += strlen(ptr);
00175 
00176               // Third line
00177               rval = 1.0;
00178               if (!data->getValue(TRANSFORMER_WINDV1,&rval,j)) {
00179                 data->getValue(BRANCH_TAP,&rval,j);
00180               } 
00181               sprintf(ptr,"%f,",rval);
00182               ptr += strlen(ptr);
00183               rval = 0.0;
00184               data->getValue(TRANSFORMER_NOMV1,&rval,j);
00185               sprintf(ptr," %f,",rval);
00186               ptr += strlen(ptr);
00187               rval = 0.0;
00188               data->getValue(TRANSFORMER_ANG1,&rval,j);
00189               sprintf(ptr," %f,",rval);
00190               ptr += strlen(ptr);
00191               rval = 0.0;
00192               data->getValue(BRANCH_RATING_A,&rval,j);
00193               sprintf(ptr," %f,",rval);
00194               ptr += strlen(ptr);
00195               rval = 0.0;
00196               data->getValue(BRANCH_RATING_B,&rval,j);
00197               sprintf(ptr," %f,",rval);
00198               ptr += strlen(ptr);
00199               rval = 0.0;
00200               data->getValue(BRANCH_RATING_C,&rval,j);
00201               sprintf(ptr," %f,",rval);
00202               ptr += strlen(ptr);
00203               ival = 0;
00204               data->getValue(TRANSFORMER_CODE1,&ival,j);
00205               sprintf(ptr," %d,",ival);
00206               ptr += strlen(ptr);
00207               ival = 0;
00208               data->getValue(TRANSFORMER_CONT1,&ival,j);
00209               sprintf(ptr," %d,",ival);
00210               ptr += strlen(ptr);
00211               rval = 1.1;
00212               data->getValue(TRANSFORMER_RMA,&rval,j);
00213               sprintf(ptr," %f,",rval);
00214               ptr += strlen(ptr);
00215               rval = 0.9;
00216               data->getValue(TRANSFORMER_RMI,&rval,j);
00217               sprintf(ptr," %f,",rval);
00218               ptr += strlen(ptr);
00219               rval = 1.1;
00220               data->getValue(TRANSFORMER_VMA,&rval,j);
00221               sprintf(ptr," %f,",rval);
00222               ptr += strlen(ptr);
00223               rval = 0.9;
00224               data->getValue(TRANSFORMER_VMI,&rval,j);
00225               sprintf(ptr," %f,",rval);
00226               ptr += strlen(ptr);
00227               ival = 33;
00228               data->getValue(TRANSFORMER_NTP,&ival,j);
00229               sprintf(ptr," %d,",ival);
00230               ptr += strlen(ptr);
00231               ival = 0;
00232               data->getValue(TRANSFORMER_TAB,&ival,j);
00233               sprintf(ptr," %d,",ival);
00234               ptr += strlen(ptr);
00235               rval = 0.0;
00236               data->getValue(TRANSFORMER_CR,&rval,j);
00237               sprintf(ptr," %f,",rval);
00238               ptr += strlen(ptr);
00239               rval = 0.0;
00240               data->getValue(TRANSFORMER_CX,&rval,j);
00241               sprintf(ptr," %f,",rval);
00242               ptr += strlen(ptr);
00243               rval = 0.0;
00244               data->getValue(TRANSFORMER_CNXA,&rval,j);
00245               sprintf(ptr," %f\n",rval);
00246               ptr += strlen(ptr);
00247 
00248               // Fourth line
00249               rval = 1.0;
00250               data->getValue(TRANSFORMER_WINDV2,&rval,j);
00251               sprintf(ptr,"%f,",rval);
00252               ptr += strlen(ptr);
00253               rval = 0.0;
00254               data->getValue(TRANSFORMER_NOMV1,&rval,j);
00255               sprintf(ptr," %f",rval);
00256               ptr += strlen(ptr);
00257               sprintf(ptr,"\n");
00258               // Finish up
00259               text_line text;
00260               strcpy(text.text,buf);
00261               text.global_idx = p_network->getGlobalBranchIndex(i);
00262               text.device_idx = j;
00263               text_data.push_back(text);
00264             }
00265           }
00266         }
00267       }
00268       if (me == 0) {
00269         fout << "0 / END LINE DATA, BEGIN TRANSFORMER DATA" << std::endl;
00270       }
00271       exprt.writeDataBlock(fout, text_data);
00272     }
00273 
00274   private:
00275     boost::shared_ptr<_network>      p_network;
00276 
00277     gridpack::parallel::Communicator p_comm;
00278 };
00279 
00280 } /* namespace export */
00281 } /* namespace gridpack */
00282 
00283 #endif /* EXPORTXFORM33_HPP_ */